#region Copyright

//  ======================================================
//      Copyright (c) 2011 Toulr All rights reserved.
//     
//      The use and distribution terms for this software are contained in the file
//      named license.txt, which can be found in the root of this distribution.
//      By using this software in any fashion, you are agreeing to be bound by the
//      terms of this license.
//     
//     You must not remove this notice, or any other, from this software.
//  ======================================================

#endregion

#region Using Namespaces

using System;
using System.Security.Cryptography;

#endregion

#if !NETCF_1_0

namespace Toulr.Util.Security
{
    /// <summary>
    ///   PkzipClassic embodies the classic or original encryption facilities used in Pkzip archives.
    ///   While it has been superceded by more recent and more powerful algorithms, its still in use and 
    ///   is viable for preventing casual snooping
    /// </summary>
    public abstract class PkzipClassic : SymmetricAlgorithm
    {
        /// <summary>
        ///   Generates new encryption keys based on given seed
        /// </summary>
        /// <param name = "seed">The seed value to initialise keys with.</param>
        /// <returns>A new key value.</returns>
        public static byte[] GenerateKeys(byte[] seed)
        {
            if (seed == null)
            {
                throw new ArgumentNullException("seed");
            }

            if (seed.Length == 0)
            {
                throw new ArgumentException("Length is zero", "seed");
            }

            var newKeys = new uint[]
                              {
                                  0x12345678,
                                  0x23456789,
                                  0x34567890
                              };

            for (int i = 0; i < seed.Length; ++i)
            {
                newKeys[0] = Crc32.ComputeCrc32(newKeys[0], seed[i]);
                newKeys[1] = newKeys[1] + (byte) newKeys[0];
                newKeys[1] = newKeys[1]*134775813 + 1;
                newKeys[2] = Crc32.ComputeCrc32(newKeys[2], (byte) (newKeys[1] >> 24));
            }

            var result = new byte[12];
            result[0] = (byte) (newKeys[0] & 0xff);
            result[1] = (byte) ((newKeys[0] >> 8) & 0xff);
            result[2] = (byte) ((newKeys[0] >> 16) & 0xff);
            result[3] = (byte) ((newKeys[0] >> 24) & 0xff);
            result[4] = (byte) (newKeys[1] & 0xff);
            result[5] = (byte) ((newKeys[1] >> 8) & 0xff);
            result[6] = (byte) ((newKeys[1] >> 16) & 0xff);
            result[7] = (byte) ((newKeys[1] >> 24) & 0xff);
            result[8] = (byte) (newKeys[2] & 0xff);
            result[9] = (byte) ((newKeys[2] >> 8) & 0xff);
            result[10] = (byte) ((newKeys[2] >> 16) & 0xff);
            result[11] = (byte) ((newKeys[2] >> 24) & 0xff);
            return result;
        }
    }

    /// <summary>
    ///   PkzipClassicCryptoBase provides the low level facilities for encryption
    ///   and decryption using the PkzipClassic algorithm.
    /// </summary>
    internal class PkzipClassicCryptoBase
    {
        /// <summary>
        ///   Transform a single byte
        /// </summary>
        /// <returns>
        ///   The transformed value
        /// </returns>
        protected byte TransformByte()
        {
            uint temp = ((_keys[2] & 0xFFFF) | 2);
            return (byte) ((temp*(temp ^ 1)) >> 8);
        }

        /// <summary>
        ///   Set the key schedule for encryption/decryption.
        /// </summary>
        /// <param name = "keyData">The data use to set the keys from.</param>
        protected void SetKeys(byte[] keyData)
        {
            if (keyData == null)
            {
                throw new ArgumentNullException("keyData");
            }

            if (keyData.Length != 12)
            {
                throw new InvalidOperationException("Key length is not valid");
            }

            _keys = new uint[3];
            _keys[0] = (uint) ((keyData[3] << 24) | (keyData[2] << 16) | (keyData[1] << 8) | keyData[0]);
            _keys[1] = (uint) ((keyData[7] << 24) | (keyData[6] << 16) | (keyData[5] << 8) | keyData[4]);
            _keys[2] = (uint) ((keyData[11] << 24) | (keyData[10] << 16) | (keyData[9] << 8) | keyData[8]);
        }

        /// <summary>
        ///   Update encryption keys
        /// </summary>
        protected void UpdateKeys(byte ch)
        {
            _keys[0] = Crc32.ComputeCrc32(_keys[0], ch);
            _keys[1] = _keys[1] + (byte) _keys[0];
            _keys[1] = _keys[1]*134775813 + 1;
            _keys[2] = Crc32.ComputeCrc32(_keys[2], (byte) (_keys[1] >> 24));
        }

        /// <summary>
        ///   Reset the internal state.
        /// </summary>
        protected void Reset()
        {
            _keys[0] = 0;
            _keys[1] = 0;
            _keys[2] = 0;
        }

        #region Instance Fields

        private uint[] _keys;

        #endregion
    }

    /// <summary>
    ///   PkzipClassic CryptoTransform for encryption.
    /// </summary>
    internal class PkzipClassicEncryptCryptoTransform : PkzipClassicCryptoBase, ICryptoTransform
    {
        /// <summary>
        ///   Initialise a new instance of <see cref = "PkzipClassicEncryptCryptoTransform"></see>
        /// </summary>
        /// <param name = "keyBlock">The key block to use.</param>
        internal PkzipClassicEncryptCryptoTransform(byte[] keyBlock)
        {
            SetKeys(keyBlock);
        }

        #region ICryptoTransform Members

        /// <summary>
        ///   Transforms the specified region of the specified byte array.
        /// </summary>
        /// <param name = "inputBuffer">The input for which to compute the transform.</param>
        /// <param name = "inputOffset">The offset into the byte array from which to begin using data.</param>
        /// <param name = "inputCount">The number of bytes in the byte array to use as data.</param>
        /// <returns>The computed transform.</returns>
        public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
        {
            var result = new byte[inputCount];
            TransformBlock(inputBuffer, inputOffset, inputCount, result, 0);
            return result;
        }

        /// <summary>
        ///   Transforms the specified region of the input byte array and copies 
        ///   the resulting transform to the specified region of the output byte array.
        /// </summary>
        /// <param name = "inputBuffer">The input for which to compute the transform.</param>
        /// <param name = "inputOffset">The offset into the input byte array from which to begin using data.</param>
        /// <param name = "inputCount">The number of bytes in the input byte array to use as data.</param>
        /// <param name = "outputBuffer">The output to which to write the transform.</param>
        /// <param name = "outputOffset">The offset into the output byte array from which to begin writing data.</param>
        /// <returns>The number of bytes written.</returns>
        public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer,
                                  int outputOffset)
        {
            for (int i = inputOffset; i < inputOffset + inputCount; ++i)
            {
                byte oldbyte = inputBuffer[i];
                outputBuffer[outputOffset++] = (byte) (inputBuffer[i] ^ TransformByte());
                UpdateKeys(oldbyte);
            }
            return inputCount;
        }

        /// <summary>
        ///   Gets a value indicating whether the current transform can be reused.
        /// </summary>
        public bool CanReuseTransform
        {
            get { return true; }
        }

        /// <summary>
        ///   Gets the size of the input data blocks in bytes.
        /// </summary>
        public int InputBlockSize
        {
            get { return 1; }
        }

        /// <summary>
        ///   Gets the size of the output data blocks in bytes.
        /// </summary>
        public int OutputBlockSize
        {
            get { return 1; }
        }

        /// <summary>
        ///   Gets a value indicating whether multiple blocks can be transformed.
        /// </summary>
        public bool CanTransformMultipleBlocks
        {
            get { return true; }
        }

        /// <summary>
        ///   Cleanup internal state.
        /// </summary>
        public void Dispose()
        {
            Reset();
        }

        #endregion
    }

    /// <summary>
    ///   PkzipClassic CryptoTransform for decryption.
    /// </summary>
    internal class PkzipClassicDecryptCryptoTransform : PkzipClassicCryptoBase, ICryptoTransform
    {
        /// <summary>
        ///   Initialise a new instance of <see cref = "PkzipClassicDecryptCryptoTransform"></see>.
        /// </summary>
        /// <param name = "keyBlock">The key block to decrypt with.</param>
        internal PkzipClassicDecryptCryptoTransform(byte[] keyBlock)
        {
            SetKeys(keyBlock);
        }

        #region ICryptoTransform Members

        /// <summary>
        ///   Transforms the specified region of the specified byte array.
        /// </summary>
        /// <param name = "inputBuffer">The input for which to compute the transform.</param>
        /// <param name = "inputOffset">The offset into the byte array from which to begin using data.</param>
        /// <param name = "inputCount">The number of bytes in the byte array to use as data.</param>
        /// <returns>The computed transform.</returns>
        public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
        {
            var result = new byte[inputCount];
            TransformBlock(inputBuffer, inputOffset, inputCount, result, 0);
            return result;
        }

        /// <summary>
        ///   Transforms the specified region of the input byte array and copies 
        ///   the resulting transform to the specified region of the output byte array.
        /// </summary>
        /// <param name = "inputBuffer">The input for which to compute the transform.</param>
        /// <param name = "inputOffset">The offset into the input byte array from which to begin using data.</param>
        /// <param name = "inputCount">The number of bytes in the input byte array to use as data.</param>
        /// <param name = "outputBuffer">The output to which to write the transform.</param>
        /// <param name = "outputOffset">The offset into the output byte array from which to begin writing data.</param>
        /// <returns>The number of bytes written.</returns>
        public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer,
                                  int outputOffset)
        {
            for (int i = inputOffset; i < inputOffset + inputCount; ++i)
            {
                var newByte = (byte) (inputBuffer[i] ^ TransformByte());
                outputBuffer[outputOffset++] = newByte;
                UpdateKeys(newByte);
            }
            return inputCount;
        }

        /// <summary>
        ///   Gets a value indicating whether the current transform can be reused.
        /// </summary>
        public bool CanReuseTransform
        {
            get { return true; }
        }

        /// <summary>
        ///   Gets the size of the input data blocks in bytes.
        /// </summary>
        public int InputBlockSize
        {
            get { return 1; }
        }

        /// <summary>
        ///   Gets the size of the output data blocks in bytes.
        /// </summary>
        public int OutputBlockSize
        {
            get { return 1; }
        }

        /// <summary>
        ///   Gets a value indicating whether multiple blocks can be transformed.
        /// </summary>
        public bool CanTransformMultipleBlocks
        {
            get { return true; }
        }

        /// <summary>
        ///   Cleanup internal state.
        /// </summary>
        public void Dispose()
        {
            Reset();
        }

        #endregion
    }

    /// <summary>
    ///   Defines a wrapper object to access the Pkzip algorithm. 
    ///   This class cannot be inherited.
    /// </summary>
    public sealed class PkzipClassicManaged : PkzipClassic
    {
        /// <summary>
        ///   Get / set the applicable block size in bits.
        /// </summary>
        /// <remarks>
        ///   The only valid block size is 8.
        /// </remarks>
        public override int BlockSize
        {
            get { return 8; }

            set
            {
                if (value != 8)
                {
                    throw new CryptographicException("Block size is invalid");
                }
            }
        }

        /// <summary>
        ///   Get an array of legal <see cref = "KeySizes">key sizes.</see>
        /// </summary>
        public override KeySizes[] LegalKeySizes
        {
            get
            {
                var keySizes = new KeySizes[1];
                keySizes[0] = new KeySizes(12*8, 12*8, 0);
                return keySizes;
            }
        }

        /// <summary>
        ///   Get an array of legal <see cref = "KeySizes">block sizes</see>.
        /// </summary>
        public override KeySizes[] LegalBlockSizes
        {
            get
            {
                var keySizes = new KeySizes[1];
                keySizes[0] = new KeySizes(1*8, 1*8, 0);
                return keySizes;
            }
        }

        /// <summary>
        ///   Get / set the key value applicable.
        /// </summary>
        public override byte[] Key
        {
            get
            {
                if (_key == null)
                {
                    GenerateKey();
                }

                if (_key != null) return (byte[]) _key.Clone();
                return null;
            }

            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }

                if (value.Length != 12)
                {
                    throw new CryptographicException("Key size is illegal");
                }

                _key = (byte[]) value.Clone();
            }
        }

        /// <summary>
        ///   Generate an initial vector.
        /// </summary>
        public override void GenerateIV()
        {
            // Do nothing.
        }

        /// <summary>
        ///   Generate a new random key.
        /// </summary>
        public override void GenerateKey()
        {
            _key = new byte[12];
            var rnd = new Random();
            rnd.NextBytes(_key);
        }

        /// <summary>
        ///   Create an encryptor.
        /// </summary>
        /// <param name = "rgbKey">The key to use for this encryptor.</param>
        /// <param name = "rgbIv">Initialisation vector for the new encryptor.</param>
        /// <returns>Returns a new PkzipClassic encryptor</returns>
        public override ICryptoTransform CreateEncryptor(
            byte[] rgbKey,
            byte[] rgbIv)
        {
            _key = rgbKey;
            return new PkzipClassicEncryptCryptoTransform(Key);
        }

        /// <summary>
        ///   Create a decryptor.
        /// </summary>
        /// <param name = "rgbKey">Keys to use for this new decryptor.</param>
        /// <param name = "rgbIv">Initialisation vector for the new decryptor.</param>
        /// <returns>Returns a new decryptor.</returns>
        public override ICryptoTransform CreateDecryptor(
            byte[] rgbKey,
            byte[] rgbIv)
        {
            _key = rgbKey;
            return new PkzipClassicDecryptCryptoTransform(Key);
        }

        #region Instance Fields

        private byte[] _key;

        #endregion
    }
}

#endif